import {
  cloneDeep,
  find
} from 'lodash-es'

/**
 * @description: 对象转数组
 * @param {*} obj 需要转换的对象
 * @param {*} fn 控制数组元素 回调参数是对象属性的键值，不传默认为 {label: 属性的键, value: 属性的值}
 * @return {*}
 */
export function objToArray(obj, fn) {
  return Object.keys(obj).map(key => {
    return fn ? fn({
      key,
      value: obj[key]
    }) : {
      label: key,
      value: obj[key]
    }
  })
}

/**
 * @description: 数组结构转化成树结构
 * @param {*} data 需要转化的数组
 * @param {*} invalId 需要排除的元素id数组
 * @param {*} id 元素id的键名
 * @param {*} parentId 父元素id的键名
 * @return {*} 转化后得到的树
 */
export const arrayToTree = function(
  data = [],
  invalId = [],
  id = 'id',
  parentId = 'parentId',
) {
  // 结果
  const result = []
  // 复制数据
  const dataTemp = cloneDeep(data)

  dataTemp.forEach((item) => {
    // 添加children
    if (!item.children) {
      item.children = []
    }

    // 去掉无效节点
    if (invalId.includes(item[id]))
      return

    // parentUuid值
    const parentIdValue = item[parentId]

    // 不存在parent值
    if (!parentIdValue) {
      item._level = 1
      result.push(item)
    } else {
      // 父对象
      const parent = find(dataTemp, node => node[id] === parentIdValue)
      // 不存在父对象
      if (!parent) {
        item._level = 1
        result.push(item)
        return
      }
      if (!parent.children) {
        parent._level = parent._level ? parent._level : 1
        parent.children = []
      }
      // 添加到父对象children
      item._level = parent._level + 1
      parent.children.push(item)
    }
  })
  return result
}

/**
 * @description: 树转化数组
 * @param {*} treeData 树
 * @param {*} childsKey 子节点的key
 * @return {*} 转化后得到的数组
 */
export const treeToArray = function(treeData = [], childsKey = 'children') {
  let result = []
  treeData.forEach((record) => {
    result.push(record)
    if (record[childsKey] && record[childsKey].length > 0) {
      const children = treeToArray(record[childsKey], childsKey)
      result = result.concat(children)
    }
  })
  return result
}